• optional

    • type_safe::basic_optional - An optional type, i.e. a type that may or may not be there.

    • type_safe::compact_floating_point_policy - A CompactPolicy for ts::compact_optional_storage for floating point types.

    • type_safe::compact_optional_storage - A StoragePolicy for ts::basic_optional that is more space efficient than ts::direct_optional_storage.

    • type_safe::copy(const optional_ref<T> &)

    • type_safe::direct_optional_storage - A StoragePolicy for ts::basic_optional that is similar to std::optional<T>'s implementation.

    • type_safe::make_optional(T &&)

    • type_safe::nullopt - Tag object of type ts::nullopt_t.

    • type_safe::nullopt_t - Tag type to mark a ts::basic_optional without a value.

    • type_safe::operator!=(const U &, const basic_optional<StoragePolicy> &) - Compares a ts::basic_optional with a value.

    • type_safe::operator!=(const basic_optional<StoragePolicy> &, const U &) - Compares a ts::basic_optional with a value.

    • type_safe::operator!=(const basic_optional<StoragePolicy> &, const basic_optional<StoragePolicy> &) - Compares two ts::basic_optional objects.

    • type_safe::operator<(const U &, const basic_optional<StoragePolicy> &) - Compares a ts::basic_optional with a value.

    • type_safe::operator<(const basic_optional<StoragePolicy> &, const U &) - Compares a ts::basic_optional with a value.

    • type_safe::operator<(const basic_optional<StoragePolicy> &, const basic_optional<StoragePolicy> &) - Compares two ts::basic_optional objects.

    • type_safe::operator<=(const U &, const basic_optional<StoragePolicy> &) - Compares a ts::basic_optional with a value.

    • type_safe::operator<=(const basic_optional<StoragePolicy> &, const U &) - Compares a ts::basic_optional with a value.

    • type_safe::operator<=(const basic_optional<StoragePolicy> &, const basic_optional<StoragePolicy> &) - Compares two ts::basic_optional objects.

    • type_safe::operator==(const U &, const basic_optional<StoragePolicy> &) - Compares a ts::basic_optional with a value.

    • type_safe::operator==(const basic_optional<StoragePolicy> &, const U &) - Compares a ts::basic_optional with a value.

    • type_safe::operator==(const basic_optional<StoragePolicy> &, const basic_optional<StoragePolicy> &) - Compares two ts::basic_optional objects.

    • type_safe::operator>(const U &, const basic_optional<StoragePolicy> &) - Compares a ts::basic_optional with a value.

    • type_safe::operator>(const basic_optional<StoragePolicy> &, const U &) - Compares a ts::basic_optional with a value.

    • type_safe::operator>(const basic_optional<StoragePolicy> &, const basic_optional<StoragePolicy> &) - Compares two ts::basic_optional objects.

    • type_safe::operator>=(const U &, const basic_optional<StoragePolicy> &) - Compares a ts::basic_optional with a value.

    • type_safe::operator>=(const basic_optional<StoragePolicy> &, const U &) - Compares a ts::basic_optional with a value.

    • type_safe::operator>=(const basic_optional<StoragePolicy> &, const basic_optional<StoragePolicy> &) - Compares two ts::basic_optional objects.

    • type_safe::opt_cref(const T &)

    • type_safe::opt_cref(const T *)

    • type_safe::opt_cref(const object_ref<T> &)

    • type_safe::opt_cref(const optional<T> &)

    • type_safe::opt_ref(T &)

    • type_safe::opt_ref(T *)

    • type_safe::opt_ref(const object_ref<T> &)

    • type_safe::opt_ref(optional<T> &)

    • type_safe::opt_xref(T &)

    • type_safe::opt_xref(T *)

    • type_safe::optional - A ts::basic_optional that uses ts::direct_optional_storage<T>.

    • type_safe::optional_for - Uses ts::optional_storage_policy_for to select the appropriate ts::basic_optional.

    • type_safe::optional_ref - A ts::basic_optional that uses ts::reference_optional_storage. It is an optional reference.

    • type_safe::optional_storage_policy_for<T&&> - Specialization of ts::optional_storage_policy_for for rvalue references.

    • type_safe::optional_storage_policy_for<T&> - Specialization of ts::optional_storage_policy_for for lvalue references.

    • type_safe::optional_storage_policy_for - Selects the storage policy used when rebinding a ts::basic_optional.

    • type_safe::optional_storage_policy_for<object_ref<T, XValue>> - Sets the ts::basic_optional storage policy for ts::object_ref to ts::reference_optional_storage.

    • type_safe::reference_optional_storage - A StoragePolicy for ts::basic_optional that allows optional references.

    • type_safe::visit(Visitor &&, Optionals &&...) - Visits a ts::basic_optional.

    • type_safe::with(Optional &&, Func &&, Args &&...) - With operation for ts::optional.

  • types

    • type_safe::abs(const SignedInteger &)

    • type_safe::abs(const UnsignedInteger &)

    • type_safe::abs(const integer<SignedInteger, Policy> &)

    • type_safe::abs(const integer<UnsignedInteger, Policy> &)

    • type_safe::advance(type_safe::index_t &, const type_safe::difference_t &)

    • type_safe::arithmetic_policy_default - The default ArithmeticPolicy.

    • type_safe::boolean - A type safe boolean class.

    • type_safe::checked_arithmetic - An ArithmeticPolicy where under/overflow throws an exception.

    • type_safe::default_arithmetic - An ArithmeticPolicy that behaves like the default integer implementations: Signed under/overflow is UB, unsigned under/overflow wraps around.

    • type_safe::difference_t - A type modelling the difference between two ts::index_t objects.

    • type_safe::distance(const type_safe::index_t &, const type_safe::index_t &)

    • type_safe::equal_to - Comparison functors similar to the std:: version, but explicitly cast the result of the comparison to bool.

    • type_safe::flag - A type safe flag, it can either be true or false.

    • type_safe::floating_point - A type safe floating point class.

    • type_safe::greater - Comparison functors similar to the std:: version, but explicitly cast the result of the comparison to bool.

    • type_safe::greater_equal - Comparison functors similar to the std:: version, but explicitly cast the result of the comparison to bool.

    • type_safe::index_t - A type modelling an index into an array.

    • type_safe::less - Comparison functors similar to the std:: version, but explicitly cast the result of the comparison to bool.

    • type_safe::less_equal - Comparison functors similar to the std:: version, but explicitly cast the result of the comparison to bool.

    • type_safe::make_signed(const Integer &)

    • type_safe::make_signed(const integer<Integer, Policy> &)

    • type_safe::make_signed_t - std::make_signed for ts::integer.

    • type_safe::make_unsigned(const Integer &)

    • type_safe::make_unsigned(const integer<Integer, Policy> &)

    • type_safe::make_unsigned_t - std::make_unsigned for ts::integer.

    • type_safe::narrow_cast(const Source &)

    • type_safe::narrow_cast(const floating_point<Source> &)

    • type_safe::narrow_cast(const integer<Source, Policy> &)

    • type_safe::next(const type_safe::index_t &, const type_safe::difference_t &)

    • type_safe::not_equal_to - Comparison functors similar to the std:: version, but explicitly cast the result of the comparison to bool.

    • type_safe::operator!=(T, const type_safe::boolean &) - ts::boolean in-equality comparison.

    • type_safe::operator!=(T, type_safe::flag) - ts::flag in-equality comparison.

    • type_safe::operator!=(const A &, const integer<B, Policy> &)

    • type_safe::operator!=(const integer<A, Policy> &, const B &)

    • type_safe::operator!=(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator!=(const type_safe::boolean &, T) - ts::boolean in-equality comparison.

    • type_safe::operator!=(const type_safe::boolean &, const type_safe::boolean &) - ts::boolean in-equality comparison.

    • type_safe::operator!=(type_safe::flag, T) - ts::flag in-equality comparison.

    • type_safe::operator!=(type_safe::flag, type_safe::flag) - ts::flag in-equality comparison.

    • type_safe::operator%(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator*(const A &, const floating_point<B> &)

    • type_safe::operator*(const floating_point<A> &, const B &)

    • type_safe::operator*(const floating_point<A> &, const floating_point<B> &)

    • type_safe::operator*(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator+(const A &, const floating_point<B> &)

    • type_safe::operator+(const floating_point<A> &, const B &)

    • type_safe::operator+(const floating_point<A> &, const floating_point<B> &)

    • type_safe::operator+(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator+(const type_safe::difference_t &, const type_safe::index_t &)

    • type_safe::operator+(const type_safe::index_t &, const type_safe::difference_t &)

    • type_safe::operator-(const A &, const floating_point<B> &)

    • type_safe::operator-(const floating_point<A> &, const B &)

    • type_safe::operator-(const floating_point<A> &, const floating_point<B> &)

    • type_safe::operator-(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator-(const type_safe::index_t &, const type_safe::difference_t &)

    • type_safe::operator-(const type_safe::index_t &, const type_safe::index_t &)

    • type_safe::operator/(const A &, const floating_point<B> &)

    • type_safe::operator/(const floating_point<A> &, const B &)

    • type_safe::operator/(const floating_point<A> &, const floating_point<B> &)

    • type_safe::operator/(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator<(const A &, const integer<B, Policy> &)

    • type_safe::operator<(const integer<A, Policy> &, const B &)

    • type_safe::operator<(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator<<(std::basic_ostream<Char, CharTraits> &, const type_safe::boolean &) - ts::boolean output operator.

    • type_safe::operator<=(const A &, const integer<B, Policy> &)

    • type_safe::operator<=(const integer<A, Policy> &, const B &)

    • type_safe::operator<=(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator==(T, const type_safe::boolean &) - ts::boolean equality comparison.

    • type_safe::operator==(T, type_safe::flag) - ts::flag equality comparison.

    • type_safe::operator==(const A &, const integer<B, Policy> &)

    • type_safe::operator==(const integer<A, Policy> &, const B &)

    • type_safe::operator==(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator==(const type_safe::boolean &, T) - ts::boolean equality comparison.

    • type_safe::operator==(const type_safe::boolean &, const type_safe::boolean &) - ts::boolean equality comparison.

    • type_safe::operator==(type_safe::flag, T) - ts::flag equality comparison.

    • type_safe::operator==(type_safe::flag, type_safe::flag) - ts::flag equality comparison.

    • type_safe::operator>(const A &, const integer<B, Policy> &)

    • type_safe::operator>(const integer<A, Policy> &, const B &)

    • type_safe::operator>(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator>=(const A &, const integer<B, Policy> &)

    • type_safe::operator>=(const integer<A, Policy> &, const B &)

    • type_safe::operator>=(const integer<A, Policy> &, const integer<B, Policy> &)

    • type_safe::operator>>(std::basic_istream<Char, CharTraits> &, integer<IntegerT, Policy> &)

    • type_safe::operator>>(std::basic_istream<Char, CharTraits> &, type_safe::boolean &) - ts::boolean input operator.

    • type_safe::prev(const type_safe::index_t &, const type_safe::difference_t &)

    • type_safe::undefined_behavior_arithmetic - An ArithmeticPolicy where under/overflow is always undefined behavior, albeit checked when assertions are enabled.

  • variant

    • type_safe::basic_variant - An improved union storing at most one of the given types at a time (or possibly none).

    • type_safe::copy(tagged_union<Types...> &, const tagged_union<Types...> &)

    • type_safe::destroy(tagged_union<Types...> &)

    • type_safe::fallback_variant - A ts::basic_variant using the ts::fallback_variant_policy.

    • type_safe::fallback_variant_policy - A variant policy for ts::basic_variant that uses a fallback type.

    • type_safe::move(tagged_union<Types...> &, tagged_union<Types...> &&)

    • type_safe::never_empty_variant_policy - A variant policy for ts::basic_variant that creates a variant which is never empty.

    • type_safe::nullvar - Tag object of type ts::nullvar_t.

    • type_safe::nullvar_t - Tag type to mark a ts::basic_variant without a value.

    • type_safe::optional_variant_policy - A variant policy for ts::basic_variant that creates a variant with explicit empty state.

    • type_safe::rarely_empty_variant_policy - A variant policy for ts::basic_variant that creates a variant which is rarely empty.

    • type_safe::tagged_union - A tagged union.

    • type_safe::union_type - Tag type so no explicit template instantiation of function parameters is required.

    • type_safe::union_types - Very basic typelist.

    • type_safe::variant - A ts::basic_variant with the recommended default semantics.

    • type_safe::variant_type - Convenience alias for ts::union_type.

    • type_safe::variant_types - Convenience alias for ts::union_types.

    • type_safe::with(basic_variant<VariantPolicy, Head, Types...> &&, Func &&, Args &&...)

    • type_safe::with(basic_variant<VariantPolicy, Head, Types...> &, Func &&, Args &&...)

    • type_safe::with(const basic_variant<VariantPolicy, Head, Types...> &&, Func &&, Args &&...)

    • type_safe::with(const basic_variant<VariantPolicy, Head, Types...> &, Func &&, Args &&...)

    • type_safe::with(const tagged_union<Types...> &&, Func &&, Args &&...)

    • type_safe::with(const tagged_union<Types...> &, Func &&, Args &&...)

    • type_safe::with(tagged_union<Types...> &&, Func &&, Args &&...)

    • type_safe::with(tagged_union<Types...> &, Func &&, Args &&...)


Documentation generated by standardese.